നിങ്ങളുടെ Next.js ആപ്ലിക്കേഷനുകളെ സംരക്ഷിക്കുന്നു: സെർവർ ആക്ഷൻ റേറ്റ് ലിമിറ്റിംഗിനും ഫോം ത്രോട്ടിലിംഗിനുമുള്ള ഒരു സമഗ്രമായ ഗൈഡ്

റിയാക്റ്റ് സെർവർ ആക്ഷനുകൾ, പ്രത്യേകിച്ച് Next.js-ൽ നടപ്പിലാക്കിയിരിക്കുന്നത്, നമ്മൾ ഫുൾ-സ്റ്റാക്ക് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്ന രീതിയിൽ ഒരു വലിയ മാറ്റത്തെ പ്രതിനിധീകരിക്കുന്നു. ക്ലയിന്റ് കമ്പോണന്റുകളെ സെർവറിൽ പ്രവർത്തിക്കുന്ന ഫംഗ്ഷനുകളെ നേരിട്ട് വിളിക്കാൻ അനുവദിക്കുന്നതിലൂടെ അവ ഡാറ്റാ മ്യൂട്ടേഷനുകൾ കാര്യക്ഷമമാക്കുന്നു, ഇത് ഫ്രണ്ടെൻഡ്, ബാക്കെൻഡ് കോഡുകൾ തമ്മിലുള്ള അതിരുകൾ ഫലപ്രദമായി മങ്ങിക്കുന്നു. ഈ മാതൃക അവിശ്വസനീയമായ ഡെവലപ്പർ അനുഭവം നൽകുകയും സ്റ്റേറ്റ് മാനേജ്മെന്റ് ലളിതമാക്കുകയും ചെയ്യുന്നു. എന്നിരുന്നാലും, വലിയ ശക്തിയോടൊപ്പം വലിയ ഉത്തരവാദിത്തവും വരുന്നു.

നിങ്ങളുടെ സെർവർ ലോജിക്കിലേക്ക് നേരിട്ടുള്ള ഒരു പാത തുറന്നുകാട്ടുന്നതിലൂടെ, സെർവർ ആക്ഷനുകൾ ദുരുദ്ദേശ്യമുള്ളവരുടെ പ്രധാന ലക്ഷ്യമായി മാറിയേക്കാം. ശരിയായ സുരക്ഷാ സംവിധാനങ്ങളില്ലെങ്കിൽ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ലളിതമായ ഫോം സ്പാം മുതൽ സങ്കീർണ്ണമായ ബ്രൂട്ട്-ഫോഴ്സ് ശ്രമങ്ങളും റിസോഴ്സ്-ഡ്രെയിനിംഗ് ഡിനയൽ-ഓഫ്-സർവീസ് (DoS) ആക്രമണങ്ങളും വരെയുള്ള നിരവധി ആക്രമണങ്ങൾക്ക് ഇരയാകാം. സെർവർ ആക്ഷനുകളെ ആകർഷകമാക്കുന്ന ലാളിത്യം തന്നെ, സുരക്ഷ ഒരു പ്രാഥമിക പരിഗണനയല്ലെങ്കിൽ അവയുടെ ബലഹീനതയുമാകാം.

ഇവിടെയാണ് റേറ്റ് ലിമിറ്റിംഗും ത്രോട്ടിലിംഗും പ്രസക്തമാകുന്നത്. ഇവ വെറും ഐച്ഛികമായ അധിക സൗകര്യങ്ങളല്ല; ഏതൊരു ആധുനിക വെബ് ആപ്ലിക്കേഷനും വേണ്ട അടിസ്ഥാന സുരക്ഷാ നടപടികളാണ്. ഈ സമഗ്രമായ ഗൈഡിൽ, എന്തുകൊണ്ടാണ് സെർവർ ആക്ഷനുകൾക്ക് റേറ്റ് ലിമിറ്റിംഗ് ഒഴിവാക്കാനാവാത്തതെന്ന് നമ്മൾ പര്യവേക്ഷണം ചെയ്യുകയും അത് എങ്ങനെ ഫലപ്രദമായി നടപ്പിലാക്കാം എന്നതിനെക്കുറിച്ച് ഘട്ടം ഘട്ടമായുള്ള പ്രായോഗിക നിർദ്ദേശങ്ങൾ നൽകുകയും ചെയ്യും. അടിസ്ഥാന ആശയങ്ങളും തന്ത്രങ്ങളും മുതൽ Next.js, Upstash Redis, റിയാക്റ്റിന്റെ ബിൽറ്റ്-ഇൻ ഹുക്കുകൾ എന്നിവ ഉപയോഗിച്ച് ഒരു തടസ്സമില്ലാത്ത ഉപയോക്തൃ അനുഭവത്തിനായി പ്രൊഡക്ഷൻ-റെഡി നടപ്പാക്കൽ വരെ എല്ലാം നമ്മൾ ഉൾക്കൊള്ളും.

എന്തുകൊണ്ടാണ് സെർവർ ആക്ഷനുകൾക്ക് റേറ്റ് ലിമിറ്റിംഗ് നിർണ്ണായകമാകുന്നത്

നിങ്ങളുടെ വെബ്സൈറ്റിലെ ഒരു പൊതു ഫോം സങ്കൽപ്പിക്കുക—ഒരു ലോഗിൻ ഫോം, ഒരു കോൺടാക്റ്റ് സമർപ്പണം, അല്ലെങ്കിൽ ഒരു കമന്റ് വിഭാഗം. ഇപ്പോൾ, ഒരു സ്ക്രിപ്റ്റ് ആ ഫോമിന്റെ സമർപ്പണ എൻഡ്‌പോയിന്റിൽ സെക്കൻഡിൽ നൂറുകണക്കിന് തവണ ഹിറ്റ് ചെയ്യുന്നത് സങ്കൽപ്പിക്കുക. അതിന്റെ പ്രത്യാഘാതങ്ങൾ ഗുരുതരമായേക്കാം.

• ബ്രൂട്ട്-ഫോഴ്സ് ആക്രമണങ്ങൾ തടയുന്നു: ലോഗിൻ അല്ലെങ്കിൽ പാസ്‌വേഡ് റീസെറ്റ് പോലുള്ള ഓതന്റിക്കേഷനുമായി ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങൾക്ക്, ഒരു ആക്രമണകാരിക്ക് ആയിരക്കണക്കിന് പാസ്‌വേഡ് കോമ്പിനേഷനുകൾ പരീക്ഷിക്കാൻ ഓട്ടോമേറ്റഡ് സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കാൻ കഴിയും. IP വിലാസം അല്ലെങ്കിൽ ഉപയോക്തൃനാമം അടിസ്ഥാനമാക്കിയുള്ള റേറ്റ് ലിമിറ്റിംഗ് കുറച്ച് പരാജയങ്ങൾക്ക് ശേഷം ഈ ശ്രമങ്ങളെ ഫലപ്രദമായി അവസാനിപ്പിക്കും.
• ഡിനയൽ-ഓഫ്-സർവീസ് (DoS) ആക്രമണങ്ങൾ ലഘൂകരിക്കുന്നു: ഒരു DoS ആക്രമണത്തിന്റെ ലക്ഷ്യം നിങ്ങളുടെ സെർവറിനെ അമിതമായ അഭ്യർത്ഥനകൾ കൊണ്ട് നിറയ്ക്കുകയാണ്, അതുവഴി യഥാർത്ഥ ഉപയോക്താക്കൾക്ക് സേവനം നൽകാൻ കഴിയാതെ വരുന്നു. ഒരു ക്ലയിന്റിന് നടത്താനാകുന്ന അഭ്യർത്ഥനകളുടെ എണ്ണം പരിമിതപ്പെടുത്തുന്നതിലൂടെ, റേറ്റ് ലിമിറ്റിംഗ് ഒരു ആദ്യ പ്രതിരോധ നിരയായി പ്രവർത്തിക്കുന്നു, നിങ്ങളുടെ സെർവറിന്റെ വിഭവങ്ങൾ സംരക്ഷിക്കുന്നു.
• വിഭവങ്ങളുടെ ഉപയോഗം നിയന്ത്രിക്കുന്നു: ഓരോ സെർവർ ആക്ഷനും വിഭവങ്ങൾ ഉപയോഗിക്കുന്നു—സിപിയു സൈക്കിളുകൾ, മെമ്മറി, ഡാറ്റാബേസ് കണക്ഷനുകൾ, കൂടാതെ മൂന്നാം കക്ഷി API കോളുകൾ വരെ. നിയന്ത്രണമില്ലാത്ത അഭ്യർത്ഥനകൾ ഒരൊറ്റ ഉപയോക്താവിന് (അല്ലെങ്കിൽ ബോട്ടിന്) ഈ വിഭവങ്ങൾ കയ്യടക്കാൻ ഇടയാക്കും, ഇത് മറ്റെല്ലാവരുടെയും പ്രകടനത്തെ മോശമാക്കും.
• സ്പാമും ദുരുപയോഗവും തടയുന്നു: ഉള്ളടക്കം സൃഷ്ടിക്കുന്ന ഫോമുകൾക്ക് (ഉദാഹരണത്തിന്, കമന്റുകൾ, റിവ്യൂകൾ, ഉപയോക്താക്കൾ സൃഷ്ടിക്കുന്ന പോസ്റ്റുകൾ), നിങ്ങളുടെ ഡാറ്റാബേസിൽ സ്പാം നിറയ്ക്കുന്നതിൽ നിന്ന് ഓട്ടോമേറ്റഡ് ബോട്ടുകളെ തടയുന്നതിന് റേറ്റ് ലിമിറ്റിംഗ് അത്യാവശ്യമാണ്.
• ചെലവുകൾ നിയന്ത്രിക്കുന്നു: ഇന്നത്തെ ക്ലൗഡ്-നേറ്റീവ് ലോകത്ത്, വിഭവങ്ങൾ നേരിട്ട് ചെലവുകളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. സെർവർലെസ് ഫംഗ്ഷനുകൾ, ഡാറ്റാബേസ് റീഡ്/റൈറ്റുകൾ, API കോളുകൾ എന്നിവയ്‌ക്കെല്ലാം ഒരു വിലയുണ്ട്. അഭ്യർത്ഥനകളിലെ ഒരു കുതിച്ചുചാട്ടം അതിശയകരമാംവിധം വലിയ ബില്ലിലേക്ക് നയിച്ചേക്കാം. ചെലവ് നിയന്ത്രിക്കുന്നതിനുള്ള ഒരു നിർണ്ണായക ഉപകരണമാണ് റേറ്റ് ലിമിറ്റിംഗ്.

പ്രധാന റേറ്റ് ലിമിറ്റിംഗ് തന്ത്രങ്ങൾ മനസ്സിലാക്കുക

കോഡിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, റേറ്റ് ലിമിറ്റിംഗിനായി ഉപയോഗിക്കുന്ന വിവിധ അൽഗോരിതങ്ങൾ മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. ഓരോന്നിനും കൃത്യത, പ്രകടനം, സങ്കീർണ്ണത എന്നിവയുടെ കാര്യത്തിൽ അതിന്റേതായ ഗുണദോഷങ്ങളുണ്ട്.

1. ഫിക്സഡ് വിൻഡോ കൗണ്ടർ

ഇതാണ് ഏറ്റവും ലളിതമായ അൽഗോരിതം. ഒരു നിശ്ചിത സമയ വിൻഡോയിൽ (ഉദാഹരണത്തിന്, 60 സെക്കൻഡ്) ഒരു ഐഡന്റിഫയറിൽ (IP വിലാസം പോലുള്ള) നിന്നുള്ള അഭ്യർത്ഥനകളുടെ എണ്ണം കണക്കാക്കി ഇത് പ്രവർത്തിക്കുന്നു. എണ്ണം ഒരു പരിധി കവിഞ്ഞാൽ, വിൻഡോ റീസെറ്റ് ചെയ്യുന്നതുവരെ കൂടുതൽ അഭ്യർത്ഥനകൾ തടയപ്പെടും.

• പ്രയോജനങ്ങൾ: നടപ്പിലാക്കാൻ എളുപ്പവും മെമ്മറി-കാര്യക്ഷമവുമാണ്.
• ദോഷങ്ങൾ: വിൻഡോയുടെ അറ്റത്ത് ട്രാഫിക്കിന്റെ ഒരു കുതിച്ചുചാട്ടത്തിന് കാരണമായേക്കാം. ഉദാഹരണത്തിന്, മിനിറ്റിൽ 100 അഭ്യർത്ഥനകളാണ് പരിധിയെങ്കിൽ, ഒരു ഉപയോക്താവിന് 00:59-ൽ 100 അഭ്യർത്ഥനകളും 01:01-ൽ മറ്റൊരു 100 അഭ്യർത്ഥനകളും നടത്താൻ കഴിയും, ഇത് വളരെ കുറഞ്ഞ സമയത്തിനുള്ളിൽ 200 അഭ്യർത്ഥനകൾക്ക് കാരണമാകും.

2. സ്ലൈഡിംഗ് വിൻഡോ ലോഗ്

ഈ രീതി ഓരോ അഭ്യർത്ഥനയ്ക്കും ഒരു ടൈംസ്റ്റാമ്പ് ഒരു ലോഗിൽ സംഭരിക്കുന്നു. പരിധി പരിശോധിക്കാൻ, ഇത് കഴിഞ്ഞ വിൻഡോയിലെ ടൈംസ്റ്റാമ്പുകളുടെ എണ്ണം കണക്കാക്കുന്നു. ഇത് വളരെ കൃത്യമാണ്.

• പ്രയോജനങ്ങൾ: വളരെ കൃത്യമാണ്, കാരണം ഇതിന് വിൻഡോ-എഡ്ജ് പ്രശ്നമില്ല.
• ദോഷങ്ങൾ: ധാരാളം മെമ്മറി ഉപയോഗിച്ചേക്കാം, കാരണം ഓരോ അഭ്യർത്ഥനയ്ക്കും ഒരു ടൈംസ്റ്റാമ്പ് സംഭരിക്കേണ്ടതുണ്ട്.

3. സ്ലൈഡിംഗ് വിൻഡോ കൗണ്ടർ

മുമ്പത്തെ രണ്ടിനും ഇടയിൽ മികച്ച സന്തുലിതാവസ്ഥ നൽകുന്ന ഒരു ഹൈബ്രിഡ് സമീപനമാണിത്. മുൻ വിൻഡോയിലെയും നിലവിലെ വിൻഡോയിലെയും അഭ്യർത്ഥനകളുടെ ഒരു വെയ്റ്റഡ് കൗണ്ട് പരിഗണിച്ച് ഇത് ബർസ്റ്റുകളെ സ്മൂത്ത് ചെയ്യുന്നു. സ്ലൈഡിംഗ് വിൻഡോ ലോഗിനേക്കാൾ വളരെ കുറഞ്ഞ മെമ്മറി ഓവർഹെഡിൽ ഇത് നല്ല കൃത്യത നൽകുന്നു.

• പ്രയോജനങ്ങൾ: നല്ല പ്രകടനം, മെമ്മറി-കാര്യക്ഷമത, ബർസ്റ്റി ട്രാഫിക്കിനെതിരെ ശക്തമായ പ്രതിരോധം നൽകുന്നു.
• ദോഷങ്ങൾ: ഫിക്സഡ് വിൻഡോയെക്കാൾ ആദ്യം മുതൽ നടപ്പിലാക്കാൻ അല്പം സങ്കീർണ്ണമാണ്.

മിക്ക വെബ് ആപ്ലിക്കേഷൻ ഉപയോഗങ്ങൾക്കും, സ്ലൈഡിംഗ് വിൻഡോ അൽഗോരിതം ആണ് ശുപാർശ ചെയ്യുന്ന ചോയ്സ്. ഭാഗ്യവശാൽ, ആധുനിക ലൈബ്രറികൾ നമുക്കായി സങ്കീർണ്ണമായ നടപ്പാക്കൽ വിശദാംശങ്ങൾ കൈകാര്യം ചെയ്യുന്നു, ഇത് തലവേദനയില്ലാതെ അതിന്റെ കൃത്യതയിൽ നിന്ന് പ്രയോജനം നേടാൻ നമ്മളെ അനുവദിക്കുന്നു.

റിയാക്റ്റ് സെർവർ ആക്ഷനുകൾക്കായി റേറ്റ് ലിമിറ്റിംഗ് നടപ്പിലാക്കുന്നു

ഇനി, നമുക്ക് കോഡിംഗ് ആരംഭിക്കാം. ഒരു Next.js ആപ്ലിക്കേഷനായി നമ്മൾ ഒരു പ്രൊഡക്ഷൻ-റെഡി റേറ്റ് ലിമിറ്റിംഗ് സൊല്യൂഷൻ നിർമ്മിക്കും. നമ്മുടെ സ്റ്റാക്ക് ഇനിപ്പറയുന്നവ ഉൾക്കൊള്ളുന്നു:

• Next.js (ആപ്പ് റൂട്ടറിനൊപ്പം): സെർവർ ആക്ഷനുകൾ നൽകുന്ന ഫ്രെയിംവർക്ക്.
• Upstash Redis: ഒരു സെർവർലെസ്, ഗ്ലോബലി ഡിസ്ട്രിബ്യൂട്ടഡ് Redis ഡാറ്റാബേസ്. ഇത് ഈ ഉപയോഗത്തിന് അനുയോജ്യമാണ്, കാരണം ഇത് അവിശ്വസനീയമാംവിധം വേഗതയേറിയതാണ് (കുറഞ്ഞ ലേറ്റൻസി പരിശോധനകൾക്ക് അനുയോജ്യം) കൂടാതെ വെർസൽ പോലുള്ള സെർവർലെസ് എൻവയോൺമെന്റുകളിൽ തടസ്സമില്ലാതെ പ്രവർത്തിക്കുന്നു.
• @upstash/ratelimit: Upstash Redis അല്ലെങ്കിൽ ഏതെങ്കിലും Redis ക്ലയിന്റുമായി വിവിധ റേറ്റ് ലിമിറ്റിംഗ് അൽഗോരിതങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള ലളിതവും ശക്തവുമായ ഒരു ലൈബ്രറി.

ഘട്ടം 1: പ്രോജക്റ്റ് സജ്ജീകരണവും ഡിപൻഡൻസികളും

ആദ്യം, ഒരു പുതിയ Next.js പ്രോജക്റ്റ് സൃഷ്ടിച്ച് ആവശ്യമായ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക.

            npx create-next-app@latest my-secure-app
cd my-secure-app
npm install @upstash/redis @upstash/ratelimit
            

              
                Copy
              
            
          

ഘട്ടം 2: Upstash Redis കോൺഫിഗർ ചെയ്യുക

1. Upstash കൺസോളിലേക്ക് പോയി ഒരു പുതിയ ഗ്ലോബൽ Redis ഡാറ്റാബേസ് സൃഷ്ടിക്കുക. ആരംഭിക്കുന്നതിന് അനുയോജ്യമായ ഒരു വലിയ സൗജന്യ ടയർ ഇതിലുണ്ട്. 2. സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, `UPSTASH_REDIS_REST_URL`, `UPSTASH_REDIS_REST_TOKEN` എന്നിവ പകർത്തുക. 3. നിങ്ങളുടെ Next.js പ്രോജക്റ്റിന്റെ റൂട്ടിൽ ഒരു `.env.local` ഫയൽ സൃഷ്ടിച്ച് നിങ്ങളുടെ ക്രെഡൻഷ്യലുകൾ ചേർക്കുക:

            UPSTASH_REDIS_REST_URL="YOUR_URL_HERE"
UPSTASH_REDIS_REST_TOKEN="YOUR_TOKEN_HERE"
            

              
                Copy
              
            
          

ഘട്ടം 3: പുനരുപയോഗിക്കാവുന്ന ഒരു റേറ്റ് ലിമിറ്റിംഗ് സേവനം സൃഷ്ടിക്കുക

നിങ്ങളുടെ റേറ്റ് ലിമിറ്റിംഗ് ലോജിക് കേന്ദ്രീകരിക്കുന്നത് ഒരു നല്ല ശീലമാണ്. നമുക്ക് `lib/rate-limiter.ts` എന്ന പേരിൽ ഒരു ഫയൽ സൃഷ്ടിക്കാം.

            // lib/rate-limiter.ts
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";
import { headers } from 'next/headers';

// Create a new Redis client instance.
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});

// Create a new ratelimiter, that allows 10 requests per 10 seconds.
export const ratelimit = new Ratelimit({
  redis: redis,
  limiter: Ratelimit.slidingWindow(10, "10 s"),
  analytics: true, // Optional: Enables analytics tracking
});

/**
 * A helper function to get the user's IP address from the request headers.
 * It prioritizes specific headers that are common in production environments.
 */
export function getIP() {
    const forwardedFor = headers().get('x-forwarded-for');
    const realIp = headers().get('x-real-ip');

    if (forwardedFor) {
        return forwardedFor.split(',')[0].trim();
    }

    if (realIp) {
        return realIp.trim();
    }

    return '127.0.0.1'; // Fallback for local development
}

            

              
                Copy
              
            
          

ഈ ഫയലിൽ, നമ്മൾ രണ്ട് പ്രധാന കാര്യങ്ങൾ ചെയ്തിട്ടുണ്ട്: 1. നമ്മുടെ എൻവയോൺമെന്റ് വേരിയബിളുകൾ ഉപയോഗിച്ച് നമ്മൾ ഒരു Redis ക്ലയിന്റ് ആരംഭിച്ചു. 2. നമ്മൾ ഒരു `Ratelimit` ഇൻസ്റ്റൻസ് സൃഷ്ടിച്ചു. നമ്മൾ `slidingWindow` അൽഗോരിതം ഉപയോഗിക്കുന്നു, ഇത് 10 സെക്കൻഡ് വിൻഡോയിൽ പരമാവധി 10 അഭ്യർത്ഥനകൾ അനുവദിക്കുന്നതിന് കോൺഫിഗർ ചെയ്തിരിക്കുന്നു. ഇത് ഒരു ന്യായമായ തുടക്കമാണ്, എന്നാൽ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ആവശ്യകതകൾക്കനുസരിച്ച് ഈ മൂല്യങ്ങൾ ക്രമീകരിക്കണം. 3. നമ്മുടെ ആപ്ലിക്കേഷൻ ഒരു പ്രോക്സി അല്ലെങ്കിൽ ലോഡ് ബാലൻസറിന് പിന്നിലായിരിക്കുമ്പോഴും (പ്രൊഡക്ഷനിൽ മിക്കവാറും എല്ലായ്പ്പോഴും അങ്ങനെയാണ്) IP വിലാസം ശരിയായി വായിക്കുന്ന ഒരു `getIP` ഹെൽപ്പർ ഫംഗ്ഷൻ നമ്മൾ ചേർത്തു.

ഘട്ടം 4: ഒരു സെർവർ ആക്ഷൻ സുരക്ഷിതമാക്കുക

നമുക്ക് ഒരു ലളിതമായ കോൺടാക്റ്റ് ഫോം ഉണ്ടാക്കി അതിന്റെ സമർപ്പണ ആക്ഷനിൽ നമ്മുടെ റേറ്റ് ലിമിറ്റർ പ്രയോഗിക്കാം.

ആദ്യം, `app/actions.ts`-ൽ സെർവർ ആക്ഷൻ ഉണ്ടാക്കുക:

            // app/actions.ts
'use server';

import { z } from 'zod';
import { ratelimit, getIP } from '@/lib/rate-limiter';

// Define the shape of our form state
export interface FormState {
    success: boolean;
    message: string;
}

const FormSchema = z.object({
    name: z.string().min(2, 'Name must be at least 2 characters.'),
    email: z.string().email('Invalid email address.'),
    message: z.string().min(10, 'Message must be at least 10 characters.'),
});

export async function submitContactForm(prevState: FormState, formData: FormData): Promise {
    // 1. RATE LIMITING LOGIC - This should be the very first thing
    const ip = getIP();
    const { success, limit, remaining, reset } = await ratelimit.limit(ip);

    if (!success) {
        const now = Date.now();
        const retryAfter = Math.floor((reset - now) / 1000);
        return {
            success: false,
            message: `Too many requests. Please try again in ${retryAfter} seconds.`,
        };
    }

    // 2. Validate form data
    const validatedFields = FormSchema.safeParse({
        name: formData.get('name'),
        email: formData.get('email'),
        message: formData.get('message'),
    });

    if (!validatedFields.success) {
        return {
            success: false,
            message: validatedFields.error.flatten().fieldErrors.message?.[0] || 'Invalid input.',
        };
    }

    // 3. Process the data (e.g., save to a database, send an email)
    console.log('Form data is valid and processed:', validatedFields.data);
    // Simulate a network delay
    await new Promise(resolve => setTimeout(resolve, 1000));

    // 4. Return a success message
    return {
        success: true,
        message: 'Your message has been sent successfully!',
    };
}

            

              
                Copy
              
            
          

മുകളിലെ ആക്ഷനിലെ പ്രധാന പോയിന്റുകൾ:

• `'use server';`: ഈ നിർദ്ദേശം ഫയലിലെ എക്സ്പോർട്ടുകളെ സെർവർ ആക്ഷനുകളായി അടയാളപ്പെടുത്തുന്നു.
• റേറ്റ് ലിമിറ്റിംഗ് ആദ്യം: `ratelimit.limit(identifier)` എന്ന കോൾ ആണ് നമ്മൾ ആദ്യം ചെയ്യുന്നത്. ഇത് നിർണ്ണായകമാണ്. അഭ്യർത്ഥന നിയമപരമാണെന്ന് അറിയുന്നതിന് മുമ്പ് നമ്മൾ ഒരു സാധുതാ പരിശോധനയോ ഡാറ്റാബേസ് ക്വറിയോ നടത്താൻ ആഗ്രഹിക്കുന്നില്ല.
• ഐഡന്റിഫയർ: റേറ്റ് ലിമിറ്റിംഗിനായി നമ്മൾ ഉപയോക്താവിന്റെ IP വിലാസം (`ip`) ഒരു അദ്വിതീയ ഐഡന്റിഫയറായി ഉപയോഗിക്കുന്നു.
• നിരസിക്കൽ കൈകാര്യം ചെയ്യൽ: `success` എന്നത് false ആണെങ്കിൽ, ഉപയോക്താവ് റേറ്റ് ലിമിറ്റ് കവിഞ്ഞു എന്നാണർത്ഥം. ഉപയോക്താവ് വീണ്ടും ശ്രമിക്കുന്നതിന് മുമ്പ് എത്ര സമയം കാത്തിരിക്കണം എന്നതുൾപ്പെടെ ഒരു ഘടനാപരമായ പിശക് സന്ദേശം നമ്മൾ ഉടൻ തിരികെ നൽകുന്നു.
• ഘടനാപരമായ സ്റ്റേറ്റ്: ആക്ഷൻ എപ്പോഴും `FormState` ഇന്റർഫേസുമായി പൊരുത്തപ്പെടുന്ന ഒരു ഒബ്ജക്റ്റ് തിരികെ നൽകി `useFormState` ഹുക്കുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. UI-ൽ ഫീഡ്‌ബാക്ക് പ്രദർശിപ്പിക്കുന്നതിന് ഇത് നിർണ്ണായകമാണ്.

ഘട്ടം 5: ഫ്രണ്ടെൻഡ് ഫോം കമ്പോണന്റ് ഉണ്ടാക്കുക

ഇപ്പോൾ, നമുക്ക് ഈ ആക്ഷൻ ഉപയോഗിക്കുകയും മികച്ച ഉപയോക്തൃ അനുഭവം നൽകുകയും ചെയ്യുന്ന `app/page.tsx`-ൽ ഒരു ക്ലയിന്റ്-സൈഡ് കമ്പോണന്റ് നിർമ്മിക്കാം.

            // app/page.tsx
'use client';

import { useFormState, useFormStatus } from 'react-dom';
import { submitContactForm, FormState } from './actions';

const initialState: FormState = {
    success: false,
    message: '',
};

function SubmitButton() {
    const { pending } = useFormStatus();

    return (
        
            {pending ? 'Submitting...' : 'Submit'}
        
    );
}

export default function ContactForm() {
    const [state, formAction] = useFormState(submitContactForm, initialState);

    return (
        

            
Contact Us
            

                

                    Name
                    
                
                

                    Email
                    
                
                

                    Message
                    
                
                
                

                {state.message && (
                    

                        {state.message}
                    
                )}
            
        
    );
}

            

              
                Copy
              
            
          

ക്ലയിന്റ് കമ്പോണന്റിന്റെ വിശദീകരണം:

• `'use client';`: ഈ കമ്പോണന്റ് ഒരു ക്ലയിന്റ് കമ്പോണന്റ് ആയിരിക്കണം, കാരണം ഇത് ഹുക്കുകൾ (`useFormState`, `useFormStatus`) ഉപയോഗിക്കുന്നു.
• `useFormState` ഹുക്ക്: ഫോം സ്റ്റേറ്റ് തടസ്സമില്ലാതെ കൈകാര്യം ചെയ്യുന്നതിനുള്ള താക്കോലാണ് ഈ ഹുക്ക്. ഇത് സെർവർ ആക്ഷനും ഒരു പ്രാരംഭ സ്റ്റേറ്റും എടുക്കുന്നു, കൂടാതെ നിലവിലെ സ്റ്റേറ്റും `
  `-ലേക്ക് പാസ്സ് ചെയ്യാനുള്ള ഒരു പൊതിഞ്ഞ ആക്ഷനും തിരികെ നൽകുന്നു. ഫോം സമർപ്പിക്കുമ്പോൾ, സെർവർ ആക്ഷന്റെ റിട്ടേൺ മൂല്യം യാന്ത്രികമായി പുതിയ `state` ആയി മാറുന്നു.
• `useFormStatus` ഹുക്ക്: ഇത് പാരന്റ് ``-ന്റെ സമർപ്പണ നില നൽകുന്നു. ആകസ്മികമായ ഡബിൾ-ക്ലിക്കുകൾ തടയുന്നതിനായി ഒരു ലോഡിംഗ് സ്റ്റേറ്റ് കാണിക്കാനും ബട്ടൺ ഡിസേബിൾ ചെയ്യാനും നമ്മൾ ഇതിന്റെ `pending` പ്രോപ്പർട്ടി നമ്മുടെ പ്രത്യേക `SubmitButton` കമ്പോണന്റിൽ ഉപയോഗിക്കുന്നു.
• ഫീഡ്‌ബാക്ക് പ്രദർശിപ്പിക്കുന്നു: നമ്മുടെ `state` ഒബ്ജക്റ്റിൽ നിന്നുള്ള `message` കാണിക്കാൻ നമ്മൾ ഒരു പാരഗ്രാഫ് സോപാധികമായി റെൻഡർ ചെയ്യുന്നു. `success` ഫ്ലാഗ് true ആണോ false ആണോ എന്നതിനെ ആശ്രയിച്ച് ടെക്സ്റ്റ് നിറം മാറുന്നു. ഇത് ഉപയോക്താവിന് ഉടനടി വ്യക്തമായ ഫീഡ്‌ബാക്ക് നൽകുന്നു, അത് ഒരു വിജയ സന്ദേശമോ, സാധുതാ പിശകോ, അല്ലെങ്കിൽ ഒരു റേറ്റ് ലിമിറ്റ് മുന്നറിയിപ്പോ ആകട്ടെ.

ഈ സജ്ജീകരണത്തിലൂടെ, ഒരു ഉപയോക്താവ് 10 സെക്കൻഡിനുള്ളിൽ 10-ൽ കൂടുതൽ തവണ ഫോം സമർപ്പിച്ചാൽ, സെർവർ ആക്ഷൻ അഭ്യർത്ഥന നിരസിക്കുകയും UI മനോഹരമായി ഒരു സന്ദേശം പ്രദർശിപ്പിക്കുകയും ചെയ്യും: "അമിതമായ അഭ്യർത്ഥനകൾ. ദയവായി 7 സെക്കൻഡിന് ശേഷം വീണ്ടും ശ്രമിക്കുക."

ഉപയോക്താക്കളെ തിരിച്ചറിയുന്നു: IP വിലാസം vs. ഉപയോക്തൃ ഐഡി

നമ്മുടെ ഉദാഹരണത്തിൽ, നമ്മൾ ഐഡന്റിഫയറായി IP വിലാസം ഉപയോഗിച്ചു. അജ്ഞാതരായ ഉപയോക്താക്കൾക്ക് ഇതൊരു മികച്ച തിരഞ്ഞെടുപ്പാണ്, എന്നാൽ ഇതിന് പരിമിതികളുണ്ട്:

• പങ്കിട്ട IP-കൾ: ഒരു കോർപ്പറേറ്റ് അല്ലെങ്കിൽ യൂണിവേഴ്സിറ്റി നെറ്റ്‌വർക്കിന് പിന്നിലുള്ള ഉപയോക്താക്കൾ ഒരേ പബ്ലിക് IP വിലാസം (നെറ്റ്‌വർക്ക് അഡ്രസ്സ് ട്രാൻസ്ലേഷൻ - NAT) പങ്കിട്ടേക്കാം. ഒരു ദുരുപയോഗം ചെയ്യുന്ന ഉപയോക്താവിന് മറ്റെല്ലാവർക്കും വേണ്ടി IP ബ്ലോക്ക് ചെയ്യാൻ കഴിയും.
• IP സ്പൂഫിംഗ്/VPN-കൾ: ദുരുദ്ദേശ്യമുള്ളവർക്ക് IP അടിസ്ഥാനമാക്കിയുള്ള പരിധികൾ മറികടക്കാൻ VPN-കളോ പ്രോക്സികളോ ഉപയോഗിച്ച് എളുപ്പത്തിൽ അവരുടെ IP വിലാസങ്ങൾ മാറ്റാൻ കഴിയും.

ഓതന്റിക്കേറ്റഡ് ഉപയോക്താക്കൾക്ക്, അവരുടെ ഉപയോക്തൃ ഐഡി അല്ലെങ്കിൽ സെഷൻ ഐഡി ഐഡന്റിഫയറായി ഉപയോഗിക്കുന്നത് കൂടുതൽ വിശ്വസനീയമാണ്. ഒരു ഹൈബ്രിഡ് സമീപനം പലപ്പോഴും മികച്ചതാണ്:

            // Inside your server action
import { auth } from './auth'; // Assuming you have an auth system like NextAuth.js or Clerk

const session = await auth();
const identifier = session?.user?.id || getIP(); // Prioritize user ID if available

const { success } = await ratelimit.limit(identifier);

            

              
                Copy
              
            
          

നിങ്ങൾക്ക് വിവിധ തരം ഉപയോക്താക്കൾക്കായി വ്യത്യസ്ത റേറ്റ് ലിമിറ്ററുകൾ പോലും സൃഷ്ടിക്കാൻ കഴിയും:

            // In lib/rate-limiter.ts
export const authenticatedRateLimiter = new Ratelimit({ /* more generous limits */ });
export const anonymousRateLimiter = new Ratelimit({ /* stricter limits */ });

            

              
                Copy
              
            
          

റേറ്റ് ലിമിറ്റിംഗിനപ്പുറം: വികസിത ഫോം ത്രോട്ടിലിംഗും UX-ഉം

സെർവർ-സൈഡ് റേറ്റ് ലിമിറ്റിംഗ് സുരക്ഷയ്ക്കുള്ളതാണ്. ക്ലയിന്റ്-സൈഡ് ത്രോട്ടിലിംഗ് ഉപയോക്തൃ അനുഭവത്തിനുള്ളതാണ്. ബന്ധമുണ്ടെങ്കിലും, അവ വ്യത്യസ്ത ഉദ്ദേശ്യങ്ങൾ നിറവേറ്റുന്നു. ക്ലയിന്റിലെ ത്രോട്ടിലിംഗ് ഉപയോക്താവിനെ അഭ്യർത്ഥന നടത്തുന്നത് പോലും തടയുന്നു, തൽക്ഷണ ഫീഡ്‌ബാക്ക് നൽകുകയും അനാവശ്യ നെറ്റ്‌വർക്ക് ട്രാഫിക് കുറയ്ക്കുകയും ചെയ്യുന്നു.

ഒരു കൗണ്ട്‌ഡൗൺ ടൈമർ ഉപയോഗിച്ച് ക്ലയിന്റ്-സൈഡ് ത്രോട്ടിലിംഗ്

നമുക്ക് നമ്മുടെ ഫോം മെച്ചപ്പെടുത്താം. ഉപയോക്താവ് റേറ്റ്-ലിമിറ്റഡ് ആകുമ്പോൾ, ഒരു സന്ദേശം കാണിക്കുന്നതിന് പകരം, നമുക്ക് സബ്മിറ്റ് ബട്ടൺ ഡിസേബിൾ ചെയ്ത് ഒരു കൗണ്ട്‌ഡൗൺ ടൈമർ കാണിക്കാം. ഇത് വളരെ മികച്ച അനുഭവം നൽകുന്നു.

ആദ്യം, നമ്മുടെ സെർവർ ആക്ഷൻ `retryAfter` ദൈർഘ്യം തിരികെ നൽകേണ്ടതുണ്ട്.

            // app/actions.ts (updated part)
export interface FormState {
    success: boolean;
    message: string;
    retryAfter?: number; // Add this new property
}

// ... inside submitContactForm
if (!success) {
    const now = Date.now();
    const retryAfter = Math.floor((reset - now) / 1000);
    return {
        success: false,
        message: `Too many requests. Please try again in a moment.`,
        retryAfter: retryAfter, // Pass the value back to the client
    };
}

            

              
                Copy
              
            
          

ഇനി, ഈ വിവരം ഉപയോഗിക്കാൻ നമ്മുടെ ക്ലയിന്റ് കമ്പോണന്റ് അപ്‌ഡേറ്റ് ചെയ്യാം.

            // app/page.tsx (updated)
'use client';

import { useEffect, useState } from 'react';
import { useFormState, useFormStatus } from 'react-dom';
import { submitContactForm, FormState } from './actions';

// ... initialState and component structure remains the same

function SubmitButton({ isThrottled, countdown }: { isThrottled: boolean; countdown: number }) {
    const { pending } = useFormStatus();
    const isDisabled = pending || isThrottled;

    return (
        
            {pending ? 'Submitting...' : isThrottled ? `Try again in ${countdown}s` : 'Submit'}
        
    );
}

export default function ContactForm() {
    const [state, formAction] = useFormState(submitContactForm, initialState);
    const [countdown, setCountdown] = useState(0);

    useEffect(() => {
        if (!state.success && state.retryAfter) {
            setCountdown(state.retryAfter);
        }
    }, [state]);

    useEffect(() => {
        if (countdown > 0) {
            const timer = setTimeout(() => setCountdown(countdown - 1), 1000);
            return () => clearTimeout(timer);
        }
    }, [countdown]);

    const isThrottled = countdown > 0;

    return (
        

            {/* ... form structure ... */}
            
                {/* ... input fields ... */}
                
                {state.message && ( /* ... */ )}
            
        
    );
}

            

              
                Copy
              
            
          

ഈ മെച്ചപ്പെടുത്തിയ പതിപ്പ് ഇപ്പോൾ ഒരു കൗണ്ട്‌ഡൗൺ ടൈമർ കൈകാര്യം ചെയ്യാൻ `useState`, `useEffect` എന്നിവ ഉപയോഗിക്കുന്നു. സെർവറിൽ നിന്നുള്ള ഫോം സ്റ്റേറ്റിൽ ഒരു `retryAfter` മൂല്യം അടങ്ങുമ്പോൾ, കൗണ്ട്‌ഡൗൺ ആരംഭിക്കുന്നു. `SubmitButton` ഡിസേബിൾ ചെയ്യുകയും ശേഷിക്കുന്ന സമയം പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു, ഇത് ഉപയോക്താവിനെ സെർവറിൽ സ്പാം ചെയ്യുന്നതിൽ നിന്ന് തടയുകയും വ്യക്തവും പ്രവർത്തനക്ഷമവുമായ ഫീഡ്‌ബാക്ക് നൽകുകയും ചെയ്യുന്നു.

മികച്ച രീതികളും ആഗോള പരിഗണനകളും

കോഡ് നടപ്പിലാക്കുന്നത് പരിഹാരത്തിന്റെ ഒരു ഭാഗം മാത്രമാണ്. ഒരു ശക്തമായ തന്ത്രത്തിൽ ഒരു സമഗ്രമായ സമീപനം ഉൾപ്പെടുന്നു.

• നിങ്ങളുടെ പ്രതിരോധങ്ങളെ തട്ടുകളായി ക്രമീകരിക്കുക: റേറ്റ് ലിമിറ്റിംഗ് ഒരു പാളിയാണ്. ശക്തമായ ഇൻപുട്ട് വാലിഡേഷൻ (നമ്മൾ ഇതിനായി Zod ഉപയോഗിച്ചു), CSRF സംരക്ഷണം (POST അഭ്യർത്ഥന ഉപയോഗിച്ച് സെർവർ ആക്ഷനുകൾക്കായി Next.js ഇത് യാന്ത്രികമായി കൈകാര്യം ചെയ്യുന്നു), കൂടാതെ ഒരു പുറം പാളി പ്രതിരോധത്തിനായി ക്ലൗഡ്‌ഫ്ലെയർ പോലുള്ള ഒരു വെബ് ആപ്ലിക്കേഷൻ ഫയർവാൾ (WAF) എന്നിവയുമായി ഇത് സംയോജിപ്പിക്കണം.
• അനുയോജ്യമായ പരിധികൾ തിരഞ്ഞെടുക്കുക: റേറ്റ് ലിമിറ്റുകൾക്ക് ഒരു മാന്ത്രിക സംഖ്യയില്ല. അതൊരു സന്തുലിതാവസ്ഥയാണ്. ഒരു ലോഗിൻ ഫോമിന് വളരെ കർശനമായ പരിധി ഉണ്ടായിരിക്കാം (ഉദാഹരണത്തിന്, 15 മിനിറ്റിനുള്ളിൽ 5 ശ്രമങ്ങൾ), അതേസമയം ഡാറ്റ ലഭ്യമാക്കുന്നതിനുള്ള ഒരു API-ക്ക് വളരെ ഉയർന്ന പരിധി ഉണ്ടായിരിക്കാം. യാഥാസ്ഥിതിക മൂല്യങ്ങളിൽ തുടങ്ങി, നിങ്ങളുടെ ട്രാഫിക് നിരീക്ഷിച്ച്, ആവശ്യാനുസരണം ക്രമീകരിക്കുക.
• ഒരു ഗ്ലോബലി ഡിസ്ട്രിബ്യൂട്ടഡ് സ്റ്റോർ ഉപയോഗിക്കുക: ഒരു ആഗോള പ്രേക്ഷകർക്ക്, ലേറ്റൻസി പ്രധാനമാണ്. തെക്കുകിഴക്കൻ ഏഷ്യയിൽ നിന്നുള്ള ഒരു അഭ്യർത്ഥനയ്ക്ക് വടക്കേ അമേരിക്കയിലെ ഒരു ഡാറ്റാബേസിൽ റേറ്റ് ലിമിറ്റ് പരിശോധിക്കേണ്ടി വരരുത്. Upstash പോലുള്ള ഒരു ഗ്ലോബലി ഡിസ്ട്രിബ്യൂട്ടഡ് Redis പ്രൊവൈഡർ ഉപയോഗിക്കുന്നത്, റേറ്റ് ലിമിറ്റ് പരിശോധനകൾ ഉപയോക്താവിനടുത്തുള്ള എഡ്ജിൽ നടക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് എല്ലാവർക്കും നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വേഗതയുള്ളതാക്കുന്നു.
• നിരീക്ഷിക്കുകയും മുന്നറിയിപ്പ് നൽകുകയും ചെയ്യുക: നിങ്ങളുടെ റേറ്റ് ലിമിറ്റർ ഒരു പ്രതിരോധ ഉപകരണം മാത്രമല്ല; അതൊരു ഡയഗ്നോസ്റ്റിക് ഉപകരണം കൂടിയാണ്. റേറ്റ്-ലിമിറ്റഡ് അഭ്യർത്ഥനകൾ ലോഗ് ചെയ്യുകയും നിരീക്ഷിക്കുകയും ചെയ്യുക. പെട്ടെന്നുള്ള ഒരു കുതിച്ചുചാട്ടം ഒരു ഏകോപിത ആക്രമണത്തിന്റെ ആദ്യ സൂചനയാകാം, ഇത് നിങ്ങളെ മുൻകൂട്ടി പ്രതികരിക്കാൻ അനുവദിക്കുന്നു.
• ഗ്രേസ്ഫുൾ ഫാൾബാക്കുകൾ: നിങ്ങളുടെ Redis ഇൻസ്റ്റൻസ് താൽക്കാലികമായി ലഭ്യമല്ലാത്തപ്പോൾ എന്ത് സംഭവിക്കും? നിങ്ങൾ ഒരു ഫാൾബാക്ക് തീരുമാനിക്കേണ്ടതുണ്ട്. അഭ്യർത്ഥന ഫെയിൽ ഓപ്പൺ (അഭ്യർത്ഥന കടന്നുപോകാൻ അനുവദിക്കുക) ആകണോ അതോ ഫെയിൽ ക്ലോസ്ഡ് (അഭ്യർത്ഥന തടയുക) ആകണോ? പേയ്‌മെന്റ് പ്രോസസ്സിംഗ് പോലുള്ള നിർണ്ണായക പ്രവർത്തനങ്ങൾക്ക്, ഫെയിൽ ക്ലോസ്ഡ് സുരക്ഷിതമാണ്. ഒരു അഭിപ്രായം പോസ്റ്റുചെയ്യുന്നത് പോലുള്ള അത്ര നിർണ്ണായകമല്ലാത്ത പ്രവർത്തനങ്ങൾക്ക്, ഫെയിൽ ഓപ്പൺ ഒരു മികച്ച ഉപയോക്തൃ അനുഭവം നൽകിയേക്കാം.

ഉപസംഹാരം

റിയാക്റ്റ് സെർവർ ആക്ഷനുകൾ ആധുനിക വെബ് വികസനം വളരെയധികം ലളിതമാക്കുന്ന ഒരു ശക്തമായ സവിശേഷതയാണ്. എന്നിരുന്നാലും, അവയുടെ നേരിട്ടുള്ള സെർവർ ആക്സസ് ഒരു സുരക്ഷാ-പ്രഥമ മാനസികാവസ്ഥ ആവശ്യപ്പെടുന്നു. ശക്തമായ റേറ്റ് ലിമിറ്റിംഗ് നടപ്പിലാക്കുന്നത് ഒരു പിൻചിന്തയല്ല - സുരക്ഷിതവും വിശ്വസനീയവും മികച്ച പ്രകടനവുമുള്ള ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു അടിസ്ഥാന ആവശ്യകതയാണ്.

Upstash Ratelimit പോലുള്ള ടൂളുകൾ ഉപയോഗിച്ച് സെർവർ-സൈഡ് എൻഫോഴ്സ്മെന്റ്, `useFormState`, `useFormStatus` പോലുള്ള ഹുക്കുകൾ ഉപയോഗിച്ച് ക്ലയിന്റ്-സൈഡിൽ ചിന്താപൂർവ്വമായ, ഉപയോക്തൃ-കേന്ദ്രീകൃത സമീപനവുമായി സംയോജിപ്പിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് മികച്ച ഉപയോക്തൃ അനുഭവം നിലനിർത്തിക്കൊണ്ട് ദുരുപയോഗത്തിൽ നിന്ന് നിങ്ങളുടെ ആപ്ലിക്കേഷനെ ഫലപ്രദമായി സംരക്ഷിക്കാൻ കഴിയും. ഈ ലേയേർഡ് സമീപനം നിങ്ങളുടെ സെർവർ ആക്ഷനുകൾ ഒരു സാധ്യതയുള്ള ബാധ്യതയാകുന്നതിന് പകരം ഒരു ശക്തമായ ആസ്തിയായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് ഒരു ആഗോള പ്രേക്ഷകർക്കായി ആത്മവിശ്വാസത്തോടെ നിർമ്മിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.